home *** CD-ROM | disk | FTP | other *** search
/ Cream of the Crop 22 / Cream of the Crop 22.iso / os2 / ext2_200.zip / EXT2_SRC.ZIP / 32BITS / EXT2-OS2 / FSD32 / FS32_MKD.C < prev    next >
C/C++ Source or Header  |  1996-09-21  |  5KB  |  156 lines
  1. //
  2. // $Header: D:/32bits/ext2-os2/fsd32/RCS/fs32_mkdir.c,v 1.1 1996/09/21 22:25:23 Willm Exp Willm $
  3. //
  4.  
  5. // 32 bits Linux ext2 file system driver for OS/2 WARP - Allows OS/2 to
  6. // access your Linux ext2fs partitions as normal drive letters.
  7. // Copyright (C) 1995, 1996 Matthieu WILLM
  8. //
  9. // This program is free software; you can redistribute it and/or modify
  10. // it under the terms of the GNU General Public License as published by
  11. // the Free Software Foundation; either version 2 of the License, or
  12. // (at your option) any later version.
  13. //
  14. // This program is distributed in the hope that it will be useful,
  15. // but WITHOUT ANY WARRANTY; without even the implied warranty of
  16. // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  17. // GNU General Public License for more details.
  18. //
  19. // You should have received a copy of the GNU General Public License
  20. // along with this program; if not, write to the Free Software
  21. // Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
  22.  
  23. #ifdef __IBMC__
  24. #pragma strings(readonly)
  25. #endif
  26.  
  27. #define INCL_DOS
  28. #define INCL_DOSERRORS
  29. #define INCL_NOPMAPI
  30. #include <os2.h>
  31.  
  32. #include <string.h>
  33.  
  34. #include <os2/types.h>
  35. #include <os2/StackToFlat.h>
  36. #include <os2/fsd32.h>
  37. #include <os2/fsh32.h>
  38. #include <os2/DevHlp32.h>
  39.  
  40. #include <linux/stat.h>
  41.  
  42. #include <os2/os2proto.h>
  43. #include <os2/ifsdbg.h>
  44. #include <os2/filefind.h>
  45. #include <os2/errors.h>
  46. #include <os2/log.h>         /* Prototypes des fonctions de log.c                      */
  47. #include <os2/volume.h>      /* Prototypes des fonctions de volume.c                   */
  48. #include <os2/files.h>       /* Prototypes des fonctions de files.c                    */
  49. #include <os2/os2misc.h>
  50. #include <os2/trace.h>
  51.  
  52. #include <linux/fs.h>
  53. #include <linux/fs_proto.h>
  54. #include <linux/ext2_fs.h>
  55. #include <linux/ext2_proto.h>
  56. #include <linux/sched.h>
  57.  
  58. #define THISFILE FILE_FS_DIR_C
  59.  
  60. /*
  61.  * struct fs32_mkdir_parms {
  62.  *     unsigned short flags;
  63.  *     PTR16          pEABuf;
  64.  *     unsigned short iCurDirEnd;
  65.  *     PTR16          pName;
  66.  *     PTR16          pcdfsd;
  67.  *     PTR16          pcdfsi;
  68.  * };
  69.  */
  70. int FS32ENTRY fs32_mkdir(struct fs32_mkdir_parms *parms) {
  71.     char           *pName;
  72.     struct cdfsi32 *pcdfsi;
  73.     union  cdfsd32 *pcdfsd;
  74.     int             rc;
  75.     struct super_block *p_volume;
  76.     char                parent[CCHMAXPATH];
  77.     char                name[CCHMAXPATH];
  78.     char               *__name = __StackToFlat(name);
  79.     struct file        *p_file;
  80.     ino_t               ino_no;
  81.     struct inode       *dir;
  82.     UINT32              mode;
  83.  
  84.  
  85.     parms = __StackToFlat(parms);
  86.  
  87.     if (Read_Write) {
  88.         if ((rc = DevHlp32_VirtToLin(parms->pcdfsi, __StackToFlat(&pcdfsi))) == NO_ERROR) {
  89.             if ((rc = DevHlp32_VirtToLin(parms->pcdfsd, __StackToFlat(&pcdfsd))) == NO_ERROR) {
  90.                 if ((rc = DevHlp32_VirtToLin(parms->pName, __StackToFlat(&pName))) == NO_ERROR) {
  91.                     if (trace_FS_MKDIR) {
  92.                         kernel_printf("FS_MKDIR pre-invocation : %s", pName);
  93.                     }
  94.  
  95.  
  96.         /*
  97.          * Checks if we must do case sensitive compares
  98.          */
  99.         mode = (is_case_retensive() ? OPENMODE_DOSBOX : 0);
  100.  
  101.         /*
  102.          * Gets the superblock from pcdfsi
  103.          */
  104.         if ((p_volume = getvolume(pcdfsi->cdi_hVPB)) != 0) {
  105.  
  106.             ExtractPath(pName, __StackToFlat(parent));
  107.             ExtractName(pName, __StackToFlat(name));
  108.             /*
  109.              * Opens the parent directory
  110.              */
  111.             if ((p_file = _open_by_name(p_volume, __StackToFlat(parent), OPENMODE_READONLY | mode)) != NULL) {
  112.                 ino_no = p_file->f_inode->i_ino;
  113.                 if ((rc = vfs_close(p_file)) == NO_ERROR) {
  114.                     dir = iget(p_volume, ino_no);
  115.                     dir->i_count++;
  116.                     down(&dir->i_sem);
  117.                     rc = dir->i_op->mkdir(dir, __StackToFlat(name), strlen(__name), 0777);
  118.                     up(&dir->i_sem);
  119.                     iput(dir);
  120.                     rc = map_err(rc);        // rc was a Linux error code (from linux/errno.h)
  121.                 } else {
  122.                     fs_err(FUNC_FS_MKDIR, FUNC_CLOSE, rc, THISFILE, __LINE__);
  123.                     rc = ERROR_CANNOT_MAKE;
  124.                 }
  125.             } else {
  126.                 fs_err(FUNC_FS_MKDIR, FUNC_OPEN_BY_NAME, -1, THISFILE, __LINE__);
  127.                 rc = ERROR_CANNOT_MAKE;
  128.             } /* end if */
  129.         } else {
  130.             kernel_printf("FS_MKDIR - couldn't retrieve superblock");
  131.             rc = ERROR_INVALID_PARAMETER;
  132.         }
  133.  
  134.     /*
  135.      * Some apps (software installer...) do rely on this, which seems to be the default
  136.      * behavior on HPFS.
  137.      */
  138.     if (rc == ERROR_FILE_EXISTS) {
  139.         rc = ERROR_ACCESS_DENIED;
  140.     }
  141.  
  142.     if (trace_FS_MKDIR) {
  143.         kernel_printf("FS_MKDIR post-invocation : rc = %d", rc);
  144.     }
  145.     return rc;
  146.             }
  147.         }
  148.     }
  149.  
  150.     } else {                 // !Read_Write
  151.         rc = ERROR_WRITE_PROTECT;
  152.     }
  153.  
  154.     return rc;
  155. }
  156.